package main

import (
	"fmt"
	"goProject/gorm/db"
	"gorm.io/gorm"
)

// 方式一：值类型，单向关系
type UserOne struct {
	gorm.Model
	Name      string
	Languages []LanguageOne `gorm:"many2many:user_languages_one;"`
}

type LanguageOne struct {
	gorm.Model
	Name string
}

// 方式二：指针类型，双向关系
type UserTwo struct {
	gorm.Model
	Name      string
	Languages []*LanguageTwo `gorm:"many2many:user_languages_two;"`
}

type LanguageTwo struct {
	gorm.Model
	Name  string
	Users []*UserTwo `gorm:"many2many:user_languages_two;"`
}

func main() {
	database := db.InitMySQL()

	// 迁移测试用的表
	database.AutoMigrate(&UserOne{}, &LanguageOne{}, &UserTwo{}, &LanguageTwo{})

	// 测试方式一：值类型，单向关系
	fmt.Println("=== 方式一：值类型，单向关系 ===")

	// 创建语言
	languages1 := []LanguageOne{
		{Name: "Go"},
		{Name: "Python"},
		{Name: "JavaScript"},
	}
	database.Create(&languages1)

	// 创建用户
	user1 := UserOne{
		Name:      "张三",
		Languages: languages1[:2], // 只会 Go 和 Python
	}
	database.Create(&user1)

	// 查询用户及其语言
	var userWithLangs UserOne
	database.Preload("Languages").First(&userWithLangs, user1.ID)
	fmt.Printf("用户：%s，会的语言：\n", userWithLangs.Name)
	for _, lang := range userWithLangs.Languages {
		fmt.Printf("  - %s\n", lang.Name)
	}

	// 无法从语言查询用户（单向关系）

	// 测试方式二：指针类型，双向关系
	fmt.Println("\n=== 方式二：指针类型，双向关系 ===")

	// 创建语言
	languages2 := []*LanguageTwo{
		{Name: "Java"},
		{Name: "C++"},
		{Name: "Rust"},
	}
	database.Create(&languages2)

	// 创建用户
	user2 := UserTwo{
		Name:      "李四",
		Languages: languages2[:2], // 只会 Java 和 C++
	}
	database.Create(&user2)

	// 查询用户及其语言
	var userWithLangs2 UserTwo
	database.Preload("Languages").First(&userWithLangs2, user2.ID)
	fmt.Printf("用户：%s，会的语言：\n", userWithLangs2.Name)
	for _, lang := range userWithLangs2.Languages {
		fmt.Printf("  - %s\n", lang.Name)
	}

	// 从语言查询用户（双向关系）
	var languageWithUsers LanguageTwo
	database.Preload("Users").First(&languageWithUsers, languages2[0].ID)
	fmt.Printf("会 %s 的用户：\n", languageWithUsers.Name)
	for _, user := range languageWithUsers.Users {
		fmt.Printf("  - %s\n", user.Name)
	}
}
